home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok02.lha / M2Code / M2ACode / M2ACode.mod < prev    next >
Encoding:
Text File  |  1993-08-16  |  18.2 KB  |  487 lines
  1. (*---------------------------------------------------------------------------
  2.    :Program.    M2ACode
  3.    :Author.     Fridtjof Björn Siebert (Amok)
  4.    :Address.    Nobileweg 67, D-7000 Stuttgart-40
  5.    :Phone.      (0)711/822509
  6.    :Shortcut.   [fbs]
  7.    :Version.    0.99
  8.    :Date.       27.03.88
  9.    :Copyright.  Intern
  10.    :Language.   Modula-II
  11.    :Translator. M2Amiga
  12.    :Imports.    none.
  13.    :Contents.   Maschinensprache->Modula Converter
  14.    :Bugs.       M2Amiga isn't able to convert some Types, such as LONGINT to
  15.    :Bugs.       WORD. REG() gives a LONGINT, so a WORD can't be a result.
  16. ---------------------------------------------------------------------------*)
  17.  
  18. (*-------------------------------------------------------------------------*)
  19. (*                            -----------------                            *)
  20. (*               -   -   -   -  M 2 A C O D E  -  -  -  -  -               *)
  21. (*                            -----------------                            *)
  22. (*                                                                         *)
  23. (*            Wandelt PC-relative (!) Maschinencodeprogramme in            *)
  24. (*       Meier-Vogt M2Amiga Definition- und Implementation-Module um.      *)
  25. (*                                                                         *)
  26. (*  © 1988 by Fridtjof Siebert                                             *)
  27. (*            Nobileweg 67                                                 *)
  28. (*            7000 Stuttgart 40 (Stammheim)                                *)
  29. (*            Germany                                                      *)
  30. (*     Phone: (0)711/822509                                                *)
  31. (*                                                                         *)
  32. (*  Usage:                                                                 *)
  33. (*  M2Code Src {-cRx:Typ|-vRx:Typ|-sRx} [-rRx:Typ] [-sall] [-d] [-e] [-p]  *)
  34. (*           (Rx: 68000-Register (D0..D7/A0..A7);)                         *)
  35. (*           (Typ: Modula-II Type)                                         *)
  36. (*                                                                         *)
  37. (*      -cRx:  konstanter Parameter wird in Rx übergeben.                  *)
  38. (*      -vRx:  Variabler Parameter in Rx übergeben.                        *)
  39. (*      -rRx:  Ergebnis wird aus Register Rx übergeben.                    *)
  40. (*      -sRx:  Die Rx muß zwischengespeichert werden (bei D2..D7 & A2..A7) *)
  41. (*      -sall: Alle Register zwischenspeichern (außer a7)                  *)
  42. (*      -d:    Letztes Wort löschen, wenn es 0 ist.                        *)
  43. (*      -e:    Entry- & Exit-Code weglassen (Prg muß mit RTS aufhören)     *)
  44. (*      -p:    Parameterübergabe nicht über Stack, sondern direkt in Regs. *)
  45. (*                                                                         *)
  46. (*  Beispiel:                                                              *)
  47. (*   M2Code  -vA0:ADDRESS -cD0:WORD -rD1:BYTE -sD3 -sD4                    *)
  48. (*     erzeugt folgende Procedur:                                          *)
  49. (*  PROCEDURE (VAR a:ADDRESS; b:WORD):BYTE                                 *)
  50. (*     D3 und D4 werden auf den Stack gerettet.                            *)
  51. (*                                                                         *)
  52. (*-------------------------------------------------------------------------*)
  53.  
  54. MODULE M2ACode;
  55.  
  56. (*------  Importlist:  ------*)
  57.  
  58. FROM SYSTEM IMPORT ADR,ADDRESS,BYTE,WORD,BITSET,SHIFT,CAST;
  59. FROM Arguments IMPORT NumArgs,GetArg;
  60. FROM Dos IMPORT Open,Close,Read,Write,FileHandlePtr,oldFile,newFile;
  61. FROM Exec IMPORT AllocMem,FreeMem,MemReqSet,MemReqs;
  62. FROM InOut IMPORT WriteString,WriteLn;
  63. FROM Strings IMPORT first,last,Delete,Copy,Insert,Compare,Length,Occurs;
  64. FROM Conversions IMPORT ValToStr;
  65.  
  66. (*------  Types:  ------*)
  67.  
  68. TYPE
  69.   String2 = ARRAY[0..2] OF CHAR;
  70.   ArgStr  = ARRAY[0..79] OF CHAR;
  71.  
  72. (*------  Variables:  ------*)
  73.  
  74. VAR
  75.   argc: CARDINAL;                     (* count args *)
  76.   argv: ARRAY[0..32] OF ArgStr;       (* the arguments *)
  77.   ParaCount: CARDINAL;                (* Counts Parameters for Procedure *)
  78.   ParaTypes: ARRAY[0..15] OF ARRAY[0..39] OF CHAR; (* the Types *)
  79.   ParaRegs: ARRAY[0..15] OF CARDINAL; (* The Registers for the Parameters *)
  80.   ParaRegStrs: ARRAY[0..15] OF String2; (* The Register's names *)
  81.   ParaVar: ARRAY[0..15] OF BOOLEAN;   (* VAR or CONST ? *)
  82.   ResultReg: INTEGER;                 (* Register for result *)
  83.   ResultType: ARRAY[0..39] OF CHAR;   (* Type of result *)
  84.   i,j: INTEGER;                       (* no special use *)
  85.   CommString: String2;                (* the first 2 chars of a argv *)
  86.   RegString: String2;                 (* the third and fourth char *)
  87.   SaveRegs: BITSET;                   (* Registers to be saved *)
  88.   LoadRegs: BITSET;                   (* Registers to be loaded *)
  89.   DoSave: BOOLEAN;                    (* Save or not ? *)
  90.   DelZero: BOOLEAN;                   (* Delete last word if it's a zero *)
  91.   NoEntryCode: BOOLEAN;               (* Don't create entry & exit code *)
  92.   NoStack: BOOLEAN;                   (* Don't use stack for Parameters *)
  93.   Char: ARRAY[0..0] OF CHAR;          (* for changing a Char to a Array of Chars *)
  94.   SourceFile, ModName, ImplFile, DefFile: ArgStr; (* The Files *)
  95.   InBuffer: POINTER TO CARDINAL;      (* Buffer for Input *)
  96.   OutBuffer: POINTER TO ARRAY[0..255] OF CHAR; (* Outputbuffer *)
  97.   InH,OutH: FileHandlePtr;            (* FileHandles for I/O *)
  98.   len: LONGCARD;                      (* for saving Writes's result *)
  99.   RegNumString: ARRAY[0..39] OF CHAR; (* the Converted Register-Number *)
  100.   Hex: ARRAY[0..39] OF CHAR;          (* for Hex-Numbers *)
  101.   ok,ok2: BOOLEAN;                    (* for getting boolean results *)
  102.   code: CARDINAL;                     (* for saving read machinecode *)
  103.  
  104. (*------  Convert Registerstring (D0,a5 etc) into number (0..15) :  -------*)
  105.  
  106. PROCEDURE CalcReg(RegStr: String2): CARDINAL;
  107.  
  108. VAR
  109.   Reg: CARDINAL;
  110.  
  111. BEGIN
  112.   IF (RegStr[0]="d") OR (RegStr[0]="D") THEN Reg := 0;
  113.   ELSIF (RegStr[0]="a") OR (RegStr[0]="A") THEN Reg := 8;
  114.   ELSE WriteString("Unknown Register"); WriteLn(); HALT; END;
  115.   Reg := Reg + CARDINAL(ORD(RegStr[1]) - ORD("0"));
  116.   IF Reg>15 THEN WriteString("Unknown Register"); WriteLn(); HALT; END;
  117.   RETURN Reg;
  118. END CalcReg;
  119.  
  120. (*---------------------  String ausgeben:  --------------------------------*)
  121.  
  122. PROCEDURE WriteBuf(Lines:CARDINAL);
  123.  
  124. BEGIN
  125.   IF Write(OutH,OutBuffer,LONGCARD(Length(OutBuffer^)))= -1 THEN
  126.     Close(OutH);
  127.     IF InH#NIL THEN Close(InH) END;
  128.     WriteString("Error while writing"); WriteLn; HALT;
  129.   END;
  130.   OutBuffer^[0] := CHR(10); len := Write(OutH,OutBuffer,1);
  131.   WHILE Lines>1 DO
  132.     len := Write(OutH,OutBuffer,1); DEC(Lines);
  133.   END;
  134. END WriteBuf;
  135.  
  136. (*-------------------  LineFeed ausgeben:  --------------------------------*)
  137.  
  138. PROCEDURE LF(Lines: CARDINAL);
  139.  
  140. BEGIN
  141.   OutBuffer^[0] := CHR(10); len := Write(OutH,OutBuffer,1);
  142.   WHILE Lines>1 DO
  143.     len := Write(OutH,OutBuffer,1); DEC(Lines);
  144.   END;
  145. END LF;
  146.  
  147. (*-------------------------  Start  ---------------------------------------*)
  148.  
  149. BEGIN
  150.  
  151. (*------  Get Commandline:  ------*)
  152.  
  153. argc := NumArgs();
  154. IF argc>33 THEN WriteString("Too many parameters"); WriteLn(); HALT; END;
  155.  
  156. (*------  No Parameters? Then type Usage:  ------*)
  157.  
  158. IF argc=0 THEN
  159.   WriteString("Usage:"); WriteLn;
  160.   WriteString("M2Code [-cRx:Type] [-vRx:Type] [-rRx:Type] [-sRx] [-sall] [-d]"); WriteLn;
  161.   WriteString(" (Rx: 68000-Register (d0..a7), Type: Modula TYPE-name)");WriteLn;
  162.   WriteLn;
  163.   WriteString("  -c    : constant Parameter"); WriteLn;
  164.   WriteString("  -v    : variable Parameter"); WriteLn;
  165.   WriteString("  -r    : Result");             WriteLn;
  166.   WriteString("  -s    : save Register ");     WriteLn;
  167.   WriteString("  -sall : save all Registers (apart from a7)"); WriteLn;
  168.   WriteString("  -d    : delete last 2 Bytes from Source, if they are zeroes"); WriteLn;
  169.   WriteString("  -e    : no entry and exit-code for the procedure"); WriteLn;
  170.   WriteString("  -p    : put parameters directly into regs, don't use Stack"); WriteLn;
  171.   WriteString(" This utility was written for Meier-Vogt M2Amiga."); WriteLn;
  172.   WriteString(" © 1988 by Fridtjof Siebert, Nobileweg 67,D-7000 Stgt-40"); WriteLn;
  173.   WriteString("    Phone: (0)711/822509"); WriteLn;
  174.   HALT;
  175. ELSE
  176.  
  177. (*------  read parameters  ------*)
  178.  
  179.   FOR i:=1 TO argc DO
  180.     GetArg(i,argv[i-1],j);
  181.   END;
  182.  
  183. END;
  184.  
  185. (*------  create Filename:  ------*)
  186.  
  187. SourceFile := argv[0];
  188. i:= Occurs(SourceFile,first,".",TRUE);
  189. IF i#last THEN
  190.   Copy(ModName,SourceFile,0,i);     (* Delete Suffix *)
  191. ELSE
  192.   ModName := SourceFile;
  193. END;
  194. ImplFile := ModName; Insert(ImplFile,last,".mod");(* add .mod for Impl. *)
  195. DefFile  := ModName; Insert(DefFile ,last,".def");      (* add .def for Def.  *)
  196.  
  197. (*------  analyse rest of commandline:  ------*)
  198.  
  199. (* Default Settings: *)
  200. DoSave := FALSE; SaveRegs := {}; LoadRegs := {}; ResultReg := -1;
  201. DelZero := FALSE; NoEntryCode := FALSE; NoStack := FALSE;
  202.  
  203. ParaCount := 0; i := 1; (* init loop *)
  204. WHILE CARDINAL(i)<argc DO
  205.   Copy (CommString,argv[i],0,2);            (* `-x' nach CommString *)
  206.   Copy (RegString ,argv[i],2,2);            (* `Rx' nach RegString  *)
  207.   IF Compare(argv[i],first,5,"-sall",FALSE)=0 THEN  (* alle Regs speichern *)
  208.     SaveRegs := {1..15}; LoadRegs := {0..14}; DoSave:= TRUE;
  209.   ELSIF Compare(CommString,first,2,"-s",FALSE)=0 THEN (* ein Reg speichern: *)
  210.     INCL(SaveRegs,15-CalcReg(RegString));
  211.     INCL(LoadRegs,   CalcReg(RegString));
  212.     DoSave := TRUE;
  213.   ELSIF Compare(CommString,first,2,"-d",TRUE)=0 THEN (* Nullwort löschen *)
  214.     DelZero := TRUE;
  215.   ELSIF Compare(CommString,first,2,"-e",TRUE)=0 THEN (* no Entry&Exit Code *)
  216.     NoEntryCode := TRUE;
  217.   ELSIF Compare(CommString,first,2,"-r",TRUE)=0 THEN (* Result in Rx *)
  218.     ResultReg := CalcReg(RegString);
  219.     Copy(ResultType,argv[i],4,Length(argv[i])-4);
  220.   ELSIF Compare(CommString,first,2,"-p",TRUE)=0 THEN (* Don't use Stack *)
  221.     NoStack := TRUE;
  222.   ELSE
  223.     IF Compare(CommString,first,2,"-c",TRUE)=0 THEN  (* Konstante übergeben: *)
  224.       ParaRegs[ParaCount] := CalcReg(RegString);
  225.       ParaRegStrs[ParaCount] := RegString; ParaVar[ParaCount] := FALSE;
  226.       Copy(ParaTypes[ParaCount],argv[i],4,Length(argv[i])-4);
  227.     ELSIF Compare(CommString,first,2,"-v",TRUE)=0 THEN (* Variable übergeben: *)
  228.       ParaRegs[ParaCount] := CalcReg(RegString);
  229.       ParaRegStrs[ParaCount] := RegString; ParaVar[ParaCount] := TRUE;
  230.       Copy(ParaTypes[ParaCount],argv[i],4,Length(argv[i])-4);
  231.     ELSE                                    (* unkorrekter Parameter: *)
  232.       WriteString("Unknown Parameter"); WriteLn(); HALT;
  233.     END;
  234.     INC(ParaCount);  (* increament number of Parameters *)
  235.     IF ParaCount=17 THEN WriteString("Too Many Parameters"); WriteLn; HALT; END;
  236.   END;
  237.   INC(i);
  238. END;
  239.  
  240. InBuffer := AllocMem(272,MemReqSet{chip,memClear}); (* Speicher *)
  241. OutBuffer := ADDRESS(LONGCARD(InBuffer) + 16);
  242.  
  243. (*------  Definition Module erzeugen:  ------*)
  244.  
  245. OutH := Open(ADR(DefFile),newFile);    (* Open defmodule for writing *)
  246. IF OutH=NIL THEN WriteString("Couldn't open "); WriteString(DefFile); WriteLn; HALT; END;
  247.  
  248. WriteLn; WriteString("Creating Definition Module: "); WriteString(DefFile);
  249. WriteLn; WriteLn; InH := NIL;
  250.  
  251. (*------  First Line:  ------*)
  252.  
  253. OutBuffer^ := "DEFINITION MODULE "; Insert(OutBuffer^,last,ModName);
  254. Insert(OutBuffer^,last,";"); WriteBuf(2);
  255.  
  256. (*------  ImportList: ------*)
  257.  
  258. OutBuffer^ := "FROM SYSTEM IMPORT BYTE,WORD,ADDRESS,BITSET,LONGSET,FFP;";
  259. WriteBuf(2);
  260.  
  261. (*------  The Procedure:  ------*)
  262.  
  263. OutBuffer^ := "(*------  "; Insert(OutBuffer^,last,ModName);
  264. Insert(OutBuffer^,last,"  ------*)"); WriteBuf(2);
  265.  
  266. OutBuffer^ := "PROCEDURE ";Insert(OutBuffer^,last,ModName);
  267. Insert(OutBuffer^,last,"("); i := 0;
  268.  
  269. (*------  create Parameterlist:  ------*)
  270.  
  271. WHILE CARDINAL(i)<ParaCount DO
  272.   IF ParaVar[i] THEN Insert(OutBuffer^,last,"VAR ") END;
  273.   IF NoStack THEN        (* parameters directly into Registers *)
  274.     Insert(OutBuffer^,last,ParaRegStrs[i]); Insert(OutBuffer^,last,"{");
  275.     ValToStr(LONGCARD(ParaRegs[i]),FALSE,Hex,10,2," ",ok);
  276.     Insert(OutBuffer^,last,Hex); Insert(OutBuffer^,last,"}");
  277.   ELSE
  278.     Char[0]:= CHR(i+97); Insert(OutBuffer^,last,Char);
  279.   END;
  280.   Insert(OutBuffer^,last,ParaTypes[i]); INC(i);
  281.   IF CARDINAL(i)<ParaCount THEN Insert(OutBuffer^,last,";"); END;
  282. END;
  283. Insert(OutBuffer^,last,")");
  284. IF ResultReg#-1 THEN Insert(OutBuffer^,last,ResultType) END;
  285. Insert(OutBuffer^,last,";"); WriteBuf(2);
  286.  
  287. (*------  The End:  ------*)
  288.  
  289. OutBuffer^ := "END "; Insert(OutBuffer^,last,ModName);
  290. Insert(OutBuffer^,last,"."); WriteBuf(1);
  291.  
  292. Close(OutH);  (* Definition Module ready *)
  293.  
  294. (*------  Implementation Module erzeugen:  ------*)
  295.  
  296. InH := Open(ADR(SourceFile),oldFile); (* open source for reading *)
  297. IF InH=NIL THEN WriteString(SourceFile); WriteString(" not found."); WriteLn; HALT END;
  298.  
  299. WriteString("Source File: "); WriteString(SourceFile); WriteLn; WriteLn;
  300.  
  301. OutH := Open(ADR(ImplFile),newFile); (* open ImplModule for writing *)
  302. IF OutH=NIL THEN Close(InH); WriteString("Couldn't open "); WriteString(ImplFile); WriteLn; HALT; END;
  303.  
  304. WriteString("Creating Implementation Module: "); WriteString(ImplFile);
  305. WriteLn; WriteLn;
  306.  
  307. (*------  First Line:  ------*)
  308.  
  309. OutBuffer^ := "IMPLEMENTATION MODULE "; Insert(OutBuffer^,last,ModName);
  310. Insert(OutBuffer^,last,";"); WriteBuf(2);
  311.  
  312. (*------  Entry and Exit code:  ------*)
  313.  
  314. IF NoEntryCode THEN OutBuffer^ := "(*$E-*)"; WriteBuf(2) END;
  315.  
  316. (*------  Importlist:  ------*)
  317.  
  318. OutBuffer^ := "FROM SYSTEM IMPORT BYTE,WORD,ADDRESS,BITSET,LONGSET,FFP,INLINE,SETREG,REG;";
  319. WriteBuf(2);
  320.  
  321. (*------  Constants for saving registers:  ------*)
  322.  
  323. IF DoSave THEN
  324.   OutBuffer^ := "CONST"; WriteBuf(1);
  325.   OutBuffer^ := "  MOVEMS = 48E7H;"; WriteBuf(1);
  326.   OutBuffer^ := "  MOVEML = 4CDFH;"; WriteBuf(2);
  327. END;
  328.  
  329. (*------  The Procedure:  ------*)
  330.  
  331. OutBuffer^ := "(*------  "; Insert(OutBuffer^,last,ModName);
  332. Insert(OutBuffer^,last,"  ------*)"); WriteBuf(2);
  333.  
  334. OutBuffer^ := "PROCEDURE "; Insert(OutBuffer^,last,ModName);
  335. Insert(OutBuffer^,last,"("); i := 0;
  336.  
  337. (*------  Create Parameterlist:  ------*)
  338.  
  339. WHILE CARDINAL(i)<ParaCount DO
  340.   IF ParaVar[i] THEN Insert(OutBuffer^,last,"VAR ") END;
  341.   IF NoStack THEN        (* parameters directly into Registers *)
  342.     Insert(OutBuffer^,last,ParaRegStrs[i]); Insert(OutBuffer^,last,"{");
  343.     ValToStr(LONGCARD(ParaRegs[i]),FALSE,Hex,10,2," ",ok);
  344.     Insert(OutBuffer^,last,Hex); Insert(OutBuffer^,last,"}");
  345.   ELSE
  346.     Char[0]:= CHR(i+97); Insert(OutBuffer^,last,Char);
  347.   END;
  348.   Insert(OutBuffer^,last,ParaTypes[i]); INC(i);
  349.   IF CARDINAL(i)<ParaCount THEN Insert(OutBuffer^,last,";"); END;
  350. END;
  351. Insert(OutBuffer^,last,")");
  352. IF ResultReg#-1 THEN Insert(OutBuffer^,last,ResultType) END;
  353. Insert(OutBuffer^,last,";"); WriteBuf(2);
  354.  
  355. (*------  begin:  ------*)
  356.  
  357. OutBuffer^ := "BEGIN"; WriteBuf(2);
  358.  
  359. (*------  Save Registers:  ------*)
  360.  
  361. IF DoSave THEN
  362.   OutBuffer^ :=  "  INLINE(MOVEMS,";
  363.   ValToStr(LONGCARD(CAST(CARDINAL,SaveRegs)),FALSE,Hex,16,5,"0",ok);
  364.   Insert(OutBuffer^,last,Hex); Insert(OutBuffer^,last,"H);");
  365.   WriteBuf(2);
  366. END;
  367.  
  368. (*------  Put parameters into Registers:  ------*)
  369.  
  370. IF NOT(NoStack) THEN
  371.   i := 0;
  372.   WHILE CARDINAL(i)<ParaCount DO
  373.     OutBuffer^ := "  SETREG(";
  374.     ValToStr(LONGCARD(ParaRegs[i]),FALSE,RegNumString,10,2," ",ok);
  375.     Insert(OutBuffer^,last,RegNumString);
  376.     Insert(OutBuffer^,last,",ADDRESS(");
  377.     Char[0] := CHR(i+97); Insert(OutBuffer^,last,Char);
  378.     Insert(OutBuffer^,last,"));"); WriteBuf(1); INC(i);
  379.   END;
  380.   LF(1);
  381. END;
  382.  
  383. (*------  insert Machine-Code:  ------*)
  384.  
  385. len := Read(InH,InBuffer,2); code := InBuffer^;
  386. OutBuffer^ := "  INLINE("; i := 0;
  387.  
  388. WHILE Read(InH,InBuffer,2)=2 DO
  389.   ValToStr(LONGCARD(code),FALSE,Hex,16,5,"0",ok);
  390.   Insert(OutBuffer^,last,Hex); Insert(OutBuffer^,last,"H");
  391.   INC(i);
  392.   IF i=8 THEN
  393.     Insert(OutBuffer^,last,");"); WriteBuf(1);
  394.     i := 0; OutBuffer^ := "  INLINE(";
  395.   ELSE
  396.     Insert(OutBuffer^,last,",");
  397.   END;
  398.   code := InBuffer^;
  399. END;
  400. IF DelZero AND (code=0) AND NOT(ODD(SHIFT(i,1))) THEN (* del Zero *)
  401.   IF i#0 THEN
  402.     Delete(OutBuffer^,Length(OutBuffer^)-1,1);
  403.     Insert(OutBuffer^,last,");");
  404.     WriteBuf(1);
  405.   END;
  406. ELSE
  407.   ValToStr(LONGCARD(code),FALSE,Hex,16,5,"0",ok);
  408.   Insert(OutBuffer^,last,Hex); Insert(OutBuffer^,last,"H);");
  409.   WriteBuf(1);
  410. END;
  411. LF(1);
  412.  
  413. (*------  get Variable parameters from Registers:  ------*)
  414.  
  415. IF NOT(NoStack) THEN
  416.   i := 0;
  417.   WHILE CARDINAL(i)<ParaCount DO
  418.     IF ParaVar[i] THEN
  419.       Char[0] := CHR(i+97);
  420.       OutBuffer^ := "  "; Insert(OutBuffer^,last,Char);
  421.       Insert(OutBuffer^,last," := ");
  422.       Copy(Hex,ParaTypes[i],1,Length(ParaTypes[i])-1); (* delete `:' *)
  423.       Insert(OutBuffer^,last,Hex);
  424.       Insert(OutBuffer^,last,"(REG(");
  425.       ValToStr(LONGCARD(ParaRegs[i]),FALSE,RegNumString,10,2," ",ok);
  426.       Insert(OutBuffer^,last,RegNumString);
  427.       Insert(OutBuffer^,last,"));"); WriteBuf(1);
  428.     END;
  429.     INC(i);
  430.   END;
  431.   IF ParaCount#0 THEN LF(1) END;
  432. END;
  433.  
  434. (*------  Return the Result:  ------*)
  435.  
  436. IF ResultReg#-1 THEN
  437.   OutBuffer^ := "  RETURN "; Insert(OutBuffer^,last,ResultType);
  438.   Delete(OutBuffer^,9,1); Insert(OutBuffer^,last,"(REG(");
  439.   ValToStr(LONGCARD(ResultReg),FALSE,RegNumString,10,2," ",ok);
  440.   Insert(OutBuffer^,last,RegNumString); Insert(OutBuffer^,last,"));");
  441.   WriteBuf(2);
  442. END;
  443.  
  444. (*------  get saved Registers back:  ------*)
  445.  
  446. IF DoSave THEN
  447.   OutBuffer^ := "  INLINE(MOVEML,";
  448.   ValToStr(LONGCARD(CAST(CARDINAL,LoadRegs)),FALSE,Hex,16,5,"0",ok);
  449.   Insert(Hex,0,"0000"); Delete(Hex,0,Length(Hex)-5);
  450.   Insert(OutBuffer^,last,Hex); Insert(OutBuffer^,last,"H);");
  451.   WriteBuf(2);
  452. END;
  453.  
  454. (*------  The End:  ------*)
  455.  
  456. OutBuffer^ := "END "; Insert(OutBuffer^,last,ModName);
  457. Insert(OutBuffer^,last,";"); WriteBuf(2);
  458.  
  459. (*------  Initialisation: (empty) ------*)
  460.  
  461. OutBuffer^ := "BEGIN"; WriteBuf(1);
  462.  
  463. OutBuffer^ := "END "; Insert(OutBuffer^,last,ModName);
  464. Insert(OutBuffer^,last,"."); WriteBuf(1);
  465.  
  466. (*------  Close Files:  ------*)
  467.  
  468. Close(OutH);
  469. Close(InH);
  470.  
  471. (*------  Get Mem back:  ------*)
  472.  
  473. FreeMem(InBuffer,272);
  474.  
  475. (*------  That's it! ------*)
  476.  
  477. END M2ACode.
  478.  
  479. (*-------------------------------------------------------------------------*)
  480. (*                                                                         *)
  481. (*   Thanks to the flu I had the week  I wrote this. Whithout it I would   *)
  482. (*   have had  to go to school  and write 3 (!!!)  tests. There wouldn't   *)
  483. (*   have been any time for me to write a programme. Now this is working   *)
  484. (*   and my flu is gone! Here comes the weekend!                           *)
  485. (*                                                                         *)
  486. (*-------------------------------------------------------------------------*)
  487.